Edwin Brady - Idris 2: Type-driven development of Idris | Code Mesh LDN 18

I don't know, some of that is at least starting to happen with Idris 2, though not in the exact way predicted: ▶ this video (Type Driven Development with Idris 2) Short summary of linked video: when your type system is powerful enough you can restrict the set of possible implementations to the point that the compiler can make a decent guess as to what the program should be to satisfy the type signature.

in “What will programming look like in 2020? (2012)” · View on HN

You don't need the tests. You need only the types. And especially you don't need "artificial dumbness", which does not understand code, and therefore won't produce correct results, but just an advanced programming language. Say hello to Idris! :-) ▶ this video

in “Fun and dystopia with AI-based code generation using GPT-J-6B” · View on HN

Idris lang seems awesome with the atom plugin. :) Did not use it yet but I hope it will get more attention. ▶ this video

in “Ask HN: What is your favorite non-generic or semi-obscure programming language?” · View on HN

Until yesterday it was officially called "Blodwen" a "prototype successor to Idris", so I assume the fact that it's now officially being called a "pre-alpha implementation of Idris 2" means it's somewhat closer to being ready, but is there some specific announcement about the exact significance of it being officially called Idris 2 now? Edit: Never mind, I found the official announcement on the Idris mailing list: [link] He says "No doubt I'll say more about this over the next few weeks," so it sounds like he's planning on making a more detailed announcement later. Edit 2: Also, as someone who hasn't been following Blodwen or how it's different from Idris 1, this looks like a good introduction: ▶ this video

in “Idris 2 programming language announced” · View on HN

Dependent types are types which depend on values. As an example, think of the cons procedure: (List A, A) -> List A. It takes a List of A's and an A and returns a List of A's. With dependent types you can write this as (List n A, A) -> List n+1 A. This tells us that cons takes a List of A's with length n and an A returns a List of A's with length n+1. Edwin Brady shows off some examples in Idris here[1]. I thought the matrix example was really impressive. [1] ▶ this video

in “Dependent Haskell” · View on HN

Refinements embed a predicate that elements of the new type must pass. def Nat = Int: (|x| -> x >= 0) Dependent types allow types to be computed from functions (and depend on arguments, otherwise it seems they become just weird constants), def Five(as_type: String) -> NumericType(as_type): match as_type: "string" => "five" "int" => 5 "float" => 5.0f "double" => 5.0d _ => panic() // Unnecessary if you refine `as_type` from a String to an enum or a fixed set of strings. Dependent types seem weird, but they help making types first-class ( ▶ this video ) and gaining types like `Array<T, N>` that allow ensuring things are the right length, and define append/extend properly.

in “What would it take to add refinement types to Rust?” · View on HN