joonazan

{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}

data One
data Succ n

data IronOre
data Iron
data CopperOre
data Copper

joonazan

struct One;
struct Succ<T>(T);

trait Pos {
    type Add<Other: Pos>: Pos;
}
impl Pos for One {
    type Add<Other: Pos> = Succ<Other>;
}
impl<T: Pos> Pos for Succ<T> {

joonazan

struct One;
struct Succ<T>(T);

trait Pos {
    type Add<Other: Pos>: Pos;
}
impl Pos for One {
    type Add<Other: Pos> = Succ<Other>;
}
impl<T: Pos> Pos for Succ<T> {

joonazan

var listSelectors = require('list-selectors');
var fs = require('fs')

module.exports = function(elmsource) {

	function makeLine(prefixedName) {
		const name = prefixedName.substr(1)
		return `${name} = "${name}"`
	}

joonazan

%default total

p_implies_p : p -> p
p_implies_p x = x

data And a b = MkAnd a b

data Or a b = Left a | Right b

p_implies_p_and_p : p -> And p p

joonazan

#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <time.h>

uint64_t water_on_pillars(uint64_t pillars[], size_t len) {

	if (len < 3) {
		return 0;
	}

joonazan

typeSignature =
    lazy <| \() ->
        sepBy (whitespace *> string "->" *> whitespace) nonFunctionType
        |> andThen (
            reducer TArrow
            >> Maybe.map succeed
            >> Maybe.withDefault (fail "expected type, got nothing")
        )

reducer : (a -> a -> a) -> List a -> Maybe a

joonazan

typeSignature =
    lazy <| \() ->
        sepBy (whitespace *> string "->" *> whitespace) nonFunctionType
        |> andThen (
            reducer TArrow
            >> Maybe.map succeed
            >> Maybe.withDefault (fail "expected type, got nothing")
        )

reducer : (a -> a -> a) -> List a -> Maybe a

joonazan

typeSignature =
    lazy <| \() ->
        sepBy (whitespace *> string "->" *> whitespace) nonFunctionType
        |> andThen (
            reducer TArrow
            >> Maybe.map succeed
            >> Maybe.withDefault (fail "expected type, got nothing")
        )

reducer : (a -> a -> a) -> List a -> Maybe a

joonazan

module ParseLibrary exposing (typeSignature)

import Combine exposing (..)
import Dict exposing (Dict)

type Type
    = TArrow Type Type
    | TName String
    | TRecord (Dict String Type)