ms-tg

/**
 * Without worrying about concurrency, we can simply cache the return value,
 *   using null to indicate that it has not yet been calculated...
 */
public class Memoize1 extends Original {
    private Integer total;    

    @Override 
    public int total() {
        if (total == null) { 

estliberitas

'use strict';

// Usage
//   node check-markdown-links.js path/to/markdown/file.md

// What it does:
// - Warns when `[ref][]` or `[title][ref]` style links don't have references defined on a page
// - Warns when `[ref]: URL` reference is not used anywhere
// - Warns when two `[ref]: URL` references point to same `URL`
// - Warns when `[ref]: URL` reference is defined in non-lexical order

jeffreyolchovy

import scala.math.{BigInt, BigDecimal}

object RecursiveStreams
{
  // natural numbers
  lazy val N: Stream[BigInt] = Stream.cons(BigInt(1), N.map(_ + 1))

  // fibonacci series
  lazy val fib: Stream[BigInt] = Stream.cons(BigInt(0), Stream.cons(BigInt(1), fib.zip(fib.tail).map(a => a._1 + a._2)))

developmentalmadness

package com.dvMENTALmadness

import akka.actor.ActorSystem
import akka.stream.ActorMaterializer
import akka.http.scaladsl.Http
import akka.http.scaladsl.model._
import scala.concurrent.Await
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

parsonsmatt

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE GADTs #-}

{-# OPTIONS_GHC -Wall #-}

module Main where

carymrobbins

{- TODO: The Num and Fractional instances don't implement all methods.
 - In practice this is fine but for completeness they should be done.
 -}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeFamilies #-}
module NumericLits where

data I = I
i :: I

dcastro

import org.scalacheck.cats.implicits._
import org.scalacheck.Gen
import io.circe.{Decoder, Encoder}

object Test extends App {
  case class X(i: Int)
  
  implicit val x: Encoder[X] = Wrapper[X].deriveInstance[Encoder]
  implicit val y: Decoder[X] = Wrapper[X].deriveInstance[Decoder].withErrorMessage("some custom error msg")
  val z: Gen[X]              = Wrapper[X].lift(Gen.choose(0, 10)) 

ChrisPenner

{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DeriveGeneric #-}

module GenericMonoid where

import Data.Monoid
import Data.Maybe

oxbowlakes

/**
 * Part Zero : 10:15 Saturday Night
 *
 * (In which we will see how to let the type system help you handle failure)...
 *
 * First let's define a domain. (All the following requires scala 2.9.x and scalaz 6.0)
 */

import scalaz._
import Scalaz._

kritzcreek

Kinds

In PureScript there are types of different kinds. Kinds are types for types. For example Int has kind Type, and we write it as Int :: Type. You can ask for the kind of a type in purs psci

> :k Int
Type

Type constructors take types to other types. For example Array (which still needs another type to form a type a value could have, like Array Int):