paf31

module Main where

import Prelude
import Data.Exists (Exists, mkExists, runExists)
import Unsafe.Coerce (unsafeCoerce)

-- Leibniz equality:
-- Two things are equal if they are substitutable in all contexts.
type Leib a b = forall f. f a -> f b

i-am-tom

module Main where

import Control.Alternative       ((<|>))
import Control.Apply             (lift2)
import Control.Monad.Eff         (Eff)
import Control.Monad.Eff.Console (CONSOLE, logShow)
import Data.Argonaut.Core        (Json)
import Data.Argonaut.Decode      (class DecodeJson, decodeJson)
import Data.Argonaut.Encode      (class EncodeJson, encodeJson)
import Data.Either               (hush)

schweigert

I am passionate about Ruby, but its execution time compared to other languages is extremely high, especially when we want to use more complex algorithms. In general, data structures in interpreted languages become incredibly slow compared to compiled languages. Some algorithms such as ´n-body´ and ´fannkuch-redux´ can be up to 30 times slower in Ruby than Go. This is one of the reasons I was interested in embedding Go code in a Ruby environment.

For those who do not know how shared libraries operate, they work in a similar way as DLLs in Windows. However, they have a native code with a direct interface to the C compiler.

Note Windows uses the DLL system, and in this case, this does not necessarily have to be in native code.

One example is DLLs written in C#, which runs on a virtual machine. Because I do not use windows, I ended up not testing if it is poss

kritzcreek

"Is Haskell a good first programming language?"

This question was asked at the recent HaskellX conference, with both practicioners as well as teachers being present. I won't reiterate everything that was said, and instead link to a recording of the podium discussion (https://skillsmatter.com/skillscasts/10952-park-bench-panel-session-with-haskellx-experts).

One particular argument, that I've heard come up multiple times now, is that teachers are complaining about the length function being polymorphic. Apparently length :: forall a. Foldable f => f a -> Int is hard to grasp/understand/accept for a new-comer. The solutions proposed to solve this problem are to:

1. Return length to its non-Foldable type
2. Use a custom Prelude to teach beginners

Drawbacks for 1 include that practicioners like the fact that length works for all kinds of data structures, and don't want that taken away from them. The primary problem with solution 2 is that students can't go and use their aquired knowledge to work on Open

mattpodwysocki

'use strict';

import * as fs from 'fs';
import { AsyncSink, AsyncIterable } from 'ix';
AsyncIterable.from(fs
    .createReadStream('some.file')
    .pipe(new AsyncSink()))
  .flatMap(file => /* yes */)
  .forEach(/* HEAVEN */)

lilactown

/**
 * Making promises
 */
let okPromise = Js.Promise.make((~resolve, ~reject as _) => [@bs] resolve("ok"));

/* Simpler promise creation for static values */
Js.Promise.resolve("easy");

Js.Promise.reject(Invalid_argument("too easy"));

mchaver

{-# LANGUAGE RankNTypes #-}

import Data.Functor.Const
import Data.Functor.Identity

type SimpleLens s a = forall f. Functor f => (a -> f a) -> s -> f s

view :: SimpleLens s a -> s -> a
view l = getConst . l Const

MicheleBertoli

class DecrementAction extends Error {}
class IncrementAction extends Error {}

const reducer = (state, error) => {
  switch (error.constructor) {
    case DecrementAction:
      return state - 1

    case IncrementAction:
      return state + 1

CMCDragonkai

Rust/Haskell: Higher-Kinded Types (HKT)

A higher kinded type is a concept that reifies a type constructor as an actual type.

A type constructor can be thought of in these analogies:

• like a function in the type universe
• as a type with a "hole" in it

ohanhi

Learning FP the hard way: Experiences on the Elm language

by Ossi Hanhinen, @ohanhi

with the support of Futurice 💚.

Licensed under CC BY 4.0.

Editorial note