Unison | A friendly, statically-typed, functional programming language from the future · Unison programming language

Comments

• Solumbran@lemmy.world ⁨10⁩ ⁨months⁩ ago

  helloWorld : '{IO, Exception} () 
  helloWorld _ = printLine "Hello World"
  

  I wouldn’t call it friendly.

  source

  • EasternLettuce@lemm.ee ⁨10⁩ ⁨months⁩ ago

    [deleted]

    source

    • dneaves@lemmy.world ⁨10⁩ ⁨months⁩ ago

      Although, i would agree with it not necessarily being “friendly”, since its a drastically different syntax than many beginners would be used to, the brackets and parenthesis here are not what you think they are.

      Unison is a language in the style of Haskell, F#, Purescript, Elm, etc. So that first line is actually type annotations.

      In Haskell, this would just be main :: IO () , meaning a function named main with no arguments and produces what is essentally a potentially-unsafe IO action with a Void return (the empty parenthesis () ).

      Here in Unison they call the bracket part “abilities” or something. Its saying the same thing as Haskell, but being more explicit in saying it can raise an exception.

      source

      • -> View More Comments
    • hansl@lemmy.world ⁨10⁩ ⁨months⁩ ago

      It’s not parenthesis (in the PEMDAS sense), it’s the unit type and it’s normally expressed like that. If you’re not familiar with type systems, it’s the typing equivalent of void.

      source

      • -> View More Comments
• RiikkaTheIcePrincess@pawb.social ⁨10⁩ ⁨months⁩ ago

  Oh, it’s weird ugly Haskell!

  … I can write weird, ugly Haskell in Haskell, though.

  source

  • hansl@lemmy.world ⁨10⁩ ⁨months⁩ ago

    Compiler, give me all the language extensions you have. Wait, wait. I’m worried what you just heard was, “Give me a lot of language extensions.” What I said was, “Give me all the language extensions you have.” Do you understand?

    source
• christophski@feddit.uk ⁨10⁩ ⁨months⁩ ago

  Literally the opposite of friendly. Already in the hello world you have two imports for extremely basic functionality (why should I have to import the ability to throw exceptions??) and a completely enigmatic symbol ’ that apparently has a significant function.

  A “friendly” programming language should be readable without knowing esoteric symbols.

  source

  • steersman2484@sh.itjust.works ⁨10⁩ ⁨months⁩ ago

    There are no imports, these are type annotations

    source

    • christophski@feddit.uk ⁨10⁩ ⁨months⁩ ago

      Do I really have to declare that something requires exceptions?

      source

      • -> View More Comments
  • daylin@lemmy.dayl.in ⁨10⁩ ⁨months⁩ ago

    What you expected sounds more like what nim offers.

    source

    • zarlin@lemmy.world ⁨10⁩ ⁨months⁩ ago

      python-level intuitive-to-read language with static typing

      Agreed, this is exactly Nim

      source
    • christophski@feddit.uk ⁨10⁩ ⁨months⁩ ago

      Thanks I’ll check it out

      source
• DrakeRichards@lemmy.world ⁨10⁩ ⁨months⁩ ago

  This looks like the opposite of friendly to me. Is it supposed to be targeted towards cloud computing or web apps? I don’t really understand what its ideal use case is.

  source
• totallynotarobot@lemmy.world ⁨10⁩ ⁨months⁩ ago

  V disappointed upon realizing this is not, as I initially read, satirically-typed

  source

  • mvirts@lemmy.world ⁨10⁩ ⁨months⁩ ago

    Time for a Java fork: Jaja

    source
• fzz@programming.dev ⁨10⁩ ⁨months⁩ ago

  Unison stores code in a database.

  🫣🤨

  source
• mindbleach@sh.itjust.works ⁨10⁩ ⁨months⁩ ago

  If I may propose a parallel to Betteridge’s law of headlines:

  Anything “of the future” is doomed.

  source
• robinm@programming.dev ⁨10⁩ ⁨months⁩ ago

  There take on what they call capabitilites is very interesting. Basically anything that would make a function non-pure seems to be declared explicitely.

  A computational effect or an “effectful” computation is one which relies on or changes elements that are outside of its immediate environment. Some examples of effectful actions that a function might take are:

  writing to a database throwing an exception making a network call getting a random number altering a global variable

  source
• onlinepersona@programming.dev ⁨10⁩ ⁨months⁩ ago

  The distributed computing aspect is very interesting, but the documentation is a mess. I applaud trying to use different and understandable terms than Haskell and other functional languages (monad, monoids, functors, applicative functor, etc.), but the examples are too verbose.

  Concerning distributed computing, writing code that seemingly has no boundaries would be a major step forward for web development. Having to split models between client and server, come up with an API that follows some convention, find a solution for client-library generation, and so much more, is tedious, repetitive, and error-prone. Having most of that handled and having blurred boundaries would make writing web applications pleasurable again.

  source
• verysoft@kbin.social ⁨10⁩ ⁨months⁩ ago

  This hurts my eyes to look at

  source
• u_tamtam@programming.dev ⁨10⁩ ⁨months⁩ ago

  “Capabilities” is the new “Functional Programming” of decades prior,

  Scala is also expanding in this area via the Caprese project: docs.scala-lang.org/scala3/reference/…/cc.html and it promises Safe Exceptions, Safe Nullability, Safe Asynchronicity in direct style/without the “what color is your function” dilemma, delineation of pure vs impure functions, … even Rust’s borrow checker (and memory guarantees) becomes a special case of Capabilities.

  I believe this is a major paradigm shift, but the ergonomics have yet to be figured out and be battle-tested in the real world. Ultimately, like for Functional Programming Languages (OCaml, F#, Haskell, …) I don’t expect pionniers like Unison/Koka/Scala to ever become mainstream, but the “good parts” to be ported to ever the more complex and clunky “general purpose” programming languages (or, why I love Scala which is multiparadigm and still very thin/clean at its core).

  source

  • sknowmads@dormi.zone ⁨10⁩ ⁨months⁩ ago

    It’s not really fair to state that functional languages aren’t battle tested or imply they aren’t useful in real world problem solving, Erlang/Elixir prove that.

    source

    • u_tamtam@programming.dev ⁨10⁩ ⁨months⁩ ago

      functional languages aren’t battle tested or imply they aren’t useful in real world problem solving

      Yup, I never said that, though? What I was about was to draw a parallel between functional programming languages and explorations from several decades ago vs the new languages and explorations going into effect typing/capabilities programming now (and the long way ahead for those).

      What I find interesting is that those pioneering FP languages never came to top the popularity chart, implying that I’m not expecting Unison to be different (but the good parts might make it into Java/C#/Python/… many years from now).

      source

      • -> View More Comments
  • Crazazy@feddit.nl ⁨10⁩ ⁨months⁩ ago

    I think that when it comes to functional programming with effect systems, unison is currently the closest to showing how it is actually done. Koka and languages like Effekt are of course very nice, but they don’t show much going for them besides the example nondeterminism and exception effect. Verse, that language that was going to be used as Fortnite’s scripting language, also plans on adding these effect systems a la Koka.

    Overall, I think one of 2 things will happen:

    • unison will slowly gain more and more adoption and grow out to become a formidable niche language
    • Verse will blow unison out of the water and everyone who once even considered unison will be moving to Verse instead

    source

    • u_tamtam@programming.dev ⁨10⁩ ⁨months⁩ ago

      unison is currently the closest to showing how it is actually done

      What makes you say that? As far as I’m aware, even the theoretical soundness of it isn’t a done deal (this is a harder nut to crack than e.g. rust’s borrow checker)

      Overall, I think one of 2 things will happen:

      In this niche, perhaps, I don’t believe any of those will gain mainstream adoption (though I hope I’m wrong)

      source
• dyc3@lemmy.world ⁨10⁩ ⁨months⁩ ago

  Bruh this looks like gibberish ong

  source
• dallo@lemmy.kiois.net ⁨10⁩ ⁨months⁩ ago

  As a F# lover I really want to see Unison take off

  source
• choroalp@programming.dev ⁨10⁩ ⁨months⁩ ago

  I tried to get into this language ablut 6 months ago and lets just say it was pure pain. Trying to make anything simple for learning was just a mess. Nearly no support from editors(Apart from VSCode but that dors not count). And Documentation was overwhelming. It may be useful in some cases but due to its sheer complexity(I didnt even managed to create a simple calculator) i dont think it would a big language.

  source
• tatterdemalion@programming.dev ⁨10⁩ ⁨months⁩ ago

  Some of the solutions it claims to provide would be genuinely great. I can’t tell if it delivers. It definitely looks pre-alpha stage.

  source