Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Activity
    Jules Ivanic
    @guizmaii
    potentiellement les performances seront tres mauvaise si l’utilisateur passe une List
    @julien-truffaut tu utilises Seq dans ton code?
    Julien Truffaut
    @julien-truffaut
    non
    Jules Ivanic
    @guizmaii
    J’ai pris pour habitude de ne pas l'utiliser
    Je suis en train de lire du code qui en est plein :/
    Julien Truffaut
    @julien-truffaut
    j'utilise List ou NonEmptyList
    si j'ai besoin de meilleur perf, Vector ou Chain, mais c'est rarement le cas
    Jules Ivanic
    @guizmaii
    Array pour des accés par index ?
    Julien Truffaut
    @julien-truffaut
    Vector est assez rapide mais oui j'imagine que Array serait mieux
    Jules Ivanic
    @guizmaii
    Je n’utilise jamais Vector car je ne comprends pas à quoi il sert
    Julien Truffaut
    @julien-truffaut
    c'est un peu un couteau suisse, Vector est plutot bon a tout
    Tu peux trouver mieux pour des operations specifiques
    en tout cas, c'est la theorie. J'ai vu certain benchmark qui disait que Vector était pas si génial (j'ai pas de lien)
    Jules Ivanic
    @guizmaii
    il y avait les benchs de Li Haoyi
    il faudrait les mettre à jour
    Yann Moisan
    @YannMoisan_twitter
    Avec Seq tu ne sais pas non plus si la sequence est finie (ça peut-être un Stream).
    Nicolas Rinaudo
    @nrinaudo
    J’utilise (immutable) seq partout ou je n’ai pas besoin de: random access, connaitre la taille, ou autre propriété spécifique (lazyness), et wue j’ai besoin d’un type concret
    Mais j’ai un lourd passé de java et c’est un automatisme dont je devrais peut etre me débarrasser
    En vrai il n’y a pas de bonne solutions, memes les jolies abstractions a la cats n’offrent que peu de garantie. Une liste infinie est foldable, tu peux essayer d’en calculer la taille
    Et les abstractions n’offrent aucune information quand aux performances- est ce que le foldl est rapide? Memory safe? Qui sait, yolo!
    etienne
    @crakjie
    L'avantage de Seq c'est que c'est quand meme plus general. Ca peut etre sympa quand tu propose un function de ne pas obliger l'appelant a recree une list ou un array si le contenus de la function n'en fait pas un usage spcifique.
    Apres je pense que Seq(1,2,3) est un mauvais reflex. Pour les perf je suis tres array. Meme un map est competitif avec eux.
    Julien Truffaut
    @julien-truffaut
    @crakjie tu peux souvent utiliser des typeclass si tu veux etre plus generique
    e.g. Foldable, Functor, Traverse
    Jonathan Winandy
    @ahoy_jon_twitter

    collection.Stream c'est comme .head des trucs à interdir via scalafix. L'avantage de Seq, c'est que cela ne va pas transformer des collections qui viennent d'ailleurs dans un data model.

    case class Address(street: String)
    case class Person(name: String, addresses: Seq[Address])

    Spark va par example nous mettre un CompactBuffer.

    Si on voulait faire ça à la main, cela donnerait un peu de L[_]

    case class Address(street: String)
    case class Person[L[_]](name: String, addresses: L[Address]) {
    
      def hasAddress(implicit L:Foldable[L]):Boolean = 
             L.collectFirst(addresses)({case _ => true}).getOrElse(false)
    }
    Jonathan Winandy
    @ahoy_jon_twitter
    L.nonEmpty(addresses)
    etienne
    @crakjie
    j'espere que ton L[_] n'est pas un Set
    Jonathan Winandy
    @ahoy_jon_twitter

    Ben ton L[_] c'est ce que tu veux, vu que le choix n'a pas été fait. Mais dans le cas d'un Set c'est galère en effet (comme le cas d'une Stream ou autre).

    On a eu des scalaistes qui on trouvé une solution pour éloigner le pb des Map[_,_] et des Set[_] ?

    Julien Truffaut
    @julien-truffaut
    dans cats tu as Foldable et UnorderedFoldable
    Jonathan Winandy
    @ahoy_jon_twitter
    👍
    Julien Truffaut
    @julien-truffaut
    Set a un UnorderedFoldable mais SortedSet a un Foldable
    Jonathan Winandy
    @ahoy_jon_twitter

    Vu que les typeclasses viennent à l'utilisation des méthodes, il n'y a pas trop de risques.

    Pour le coup :

    case class Address(street: String)
    case class Person[L[_]](name: String, addresses: L[Address]) {
    
      def hasAddress(implicit L: UnorderedFoldable[L]):Boolean = 
             L.nonEmpty(addresses)
    
      def firstAddress(implicit L:Foldable[L]):Option[Address] = 
            L.get(addresses)(0)
    }
    Jonathan Winandy
    @ahoy_jon_twitter

    Je n'utilise pas trop Cats en ce moment, je suis dans une période où les higher kinded types ne me font pas rêver. Si je dois maintenir du code avec un L[_], pourquoi pas si c'est bien fait, mais sinon Seq[_] + Scalafix !

    (ceci étant dit : cet article est vraiment pas mal : https://typelevel.org/blog/2014/06/22/mapping-sets.html)

    Jules Ivanic
    @guizmaii
    Je ne sais pas si vous les avez vu passer mais j’ai eu des reponses interessantes sur Twitter a propos de l’usage de Vector: https://twitter.com/guizmaii/status/1217078294413225984?s=20
    Francois Armand
    @fanf
    @guizmaii non, merci c'était intéressant. En gros, List quoi :)
    Jules Ivanic
    @guizmaii
    @fanf Apparemment Vector va devenir vraiment intéressant vu cette reponse: https://twitter.com/Odomontois/status/1217103996420337664?s=20
    etienne
    @crakjie
    @guizmaii Il faut voir si il tien la comparaison avec les tableaux
    Jules Ivanic
    @guizmaii
    Tableaux?
    etienne
    @crakjie
    Array lol
    Francois Armand
    @fanf
    les stats ne sont pas aussi bonne que pensé initialement, cf les commentaires à la fin (et les mesure de perf, c'est horrible). Et si tu fais essentiellement append / map / flatMap, list reste mieux
    (sauf pour la compacité et du coup peut-être le gc)
    Jonathan Winandy
    @ahoy_jon_twitter
    Personne n'est allé voir la psp-std ?
    Jules Ivanic
    @guizmaii

    Personne n'est allé voir la psp-std ?

    Paul maintien enore ça?

    Francois Armand
    @fanf
    non
    @ahoy_jon_twitter du coup ca colle pile poil avec ce que je disais: list c'est bien mieux pour une utilisation fonctionnel classique (avec append / déconstruction pour le recursif + map, filter, etc) mais ca consomme plein de ram
    un jour, on aura peut être un vrai lazy -array avec zio
    Jules Ivanic
    @guizmaii
    Tu utilises Chunk?