<meta charset="utf-8">

<title>Lambda by palatable</title>

<link rel="stylesheet" href="stylesheets/styles.css">

<link rel="stylesheet" href="stylesheets/github-light.css">

<script src="javascripts/scale.fix.js"></script>

<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">

<div class="wrapper">

<header>

<h1 class="header">Lambda</h1>

<p class="header">Functional patterns for Java</p>

<ul>

<li class="download"><a class="buttons" href="https://github.com/palatable/lambda/zipball/master">Download ZIP</a></li>

<li class="download"><a class="buttons" href="https://github.com/palatable/lambda/tarball/master">Download TAR</a></li>

<li><a class="buttons github" href="https://github.com/palatable/lambda">View On GitHub</a></li>

</ul>

<p class="header">This project is maintained by <a class="header name" href="https://github.com/palatable">palatable</a></p>

</header>

<section>

<h1>

<a href="#coproducts">CoProducts</a>

&lt;<span class="pl-ent">version</span>&gt;1.5.3&lt;/<span class="pl-ent">version</span>&gt;

<div class="highlight highlight-source-groovy-gradle"><pre>compile <span class="pl-c1">group</span>: <span class="pl-s"><span class="pl-pds">'</span>com.jnape.palatable<span class="pl-pds">'</span></span>, <span class="pl-c1">name</span>: <span class="pl-s"><span class="pl-pds">'</span>lambda<span class="pl-pds">'</span></span>, <span class="pl-c1">version</span>: <span class="pl-s"><span class="pl-pds">'</span>1.5.3<span class="pl-pds">'</span></span></pre></div>

<span class="pl-k">Fn1&lt;<span class="pl-smi">Integer</span>, <span class="pl-smi">Integer</span>&gt;</span> alsoNoOp <span class="pl-k">=</span> subtract<span class="pl-k">.</span>compose(add);</pre></div>

<p><code>Index</code> can be used for type-safe retrieval and updating of elements at specific indexes:</p>

<div class="highlight highlight-source-java"><pre><span class="pl-k">HCons&lt;<span class="pl-smi">Integer</span>, <span class="pl-k">HCons&lt;<span class="pl-smi">String</span>, <span class="pl-k">HCons&lt;<span class="pl-smi">Character</span>, <span class="pl-smi">HNil</span>&gt;</span>&gt;</span>&gt;</span> hList <span class="pl-k">=</span> cons(<span class="pl-c1">1</span>, cons(<span class="pl-s"><span class="pl-pds">"</span>2<span class="pl-pds">"</span></span>, cons(<span class="pl-s"><span class="pl-pds">'</span>3<span class="pl-pds">'</span></span>, nil())));

<span class="pl-k">HCons&lt;<span class="pl-smi">Integer</span>, <span class="pl-k">Tuple2&lt;<span class="pl-smi">String</span>, <span class="pl-smi">Character</span>&gt;</span>&gt;</span> tuple <span class="pl-k">=</span> tuple(<span class="pl-c1">1</span>, <span class="pl-s"><span class="pl-pds">"</span>2<span class="pl-pds">"</span></span>, <span class="pl-s"><span class="pl-pds">'</span>3<span class="pl-pds">'</span></span>);

<span class="pl-k">Tuple5&lt;<span class="pl-smi">Integer</span>, <span class="pl-smi">String</span>, <span class="pl-smi">Character</span>, <span class="pl-smi">Double</span>, <span class="pl-smi">Boolean</span>&gt;</span> longerHList <span class="pl-k">=</span> tuple(<span class="pl-c1">1</span>, <span class="pl-s"><span class="pl-pds">"</span>2<span class="pl-pds">"</span></span>, <span class="pl-s"><span class="pl-pds">'</span>3<span class="pl-pds">'</span></span>, <span class="pl-c1">4.0d</span>, <span class="pl-c1">false</span>);

<span class="pl-k">Index&lt;<span class="pl-smi">Character</span>, <span class="pl-k">HCons&lt;<span class="pl-smi">Integer</span>, ? extends <span class="pl-k">HCons&lt;<span class="pl-smi">String</span>, ? extends <span class="pl-k">HCons&lt;<span class="pl-smi">Character</span>, ?&gt;</span>&gt;</span>&gt;</span>&gt;</span> characterIndex <span class="pl-k">=</span>

<span class="pl-smi">Index</span><span class="pl-k">.</span><span class="pl-k">&lt;</span><span class="pl-smi">Character</span><span class="pl-k">&gt;</span>index()<span class="pl-c1">.</span><span class="pl-k">&lt;</span><span class="pl-smi">String</span><span class="pl-k">&gt;</span>after()<span class="pl-k">.</span>after();

characterIndex<span class="pl-k">.</span>get(hList); <span class="pl-c">// '3'</span>

characterIndex<span class="pl-k">.</span>get(tuple); <span class="pl-c">// '3'</span>

characterIndex<span class="pl-k">.</span>get(longerHList); <span class="pl-c">// '3'</span>

characterIndex<span class="pl-k">.</span>set(<span class="pl-s"><span class="pl-pds">'</span>4<span class="pl-pds">'</span></span>, hList); <span class="pl-c">// HList{ 1 :: "2" :: '4' }</span></pre></div>

<a id="coproducts" class="anchor" href="#coproducts" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a><a name="coproducts">CoProducts</a>

<p><code>CoProduct</code>s generalize unions of disparate types in a single consolidated type. </p>

<div class="highlight highlight-source-java"><pre><span class="pl-k">CoProduct3&lt;<span class="pl-smi">String</span>, <span class="pl-smi">Integer</span>, <span class="pl-smi">Character</span>&gt;</span> string <span class="pl-k">=</span> <span class="pl-smi">CoProduct3</span><span class="pl-k">.</span>a(<span class="pl-s"><span class="pl-pds">"</span>string<span class="pl-pds">"</span></span>);

<span class="pl-k">CoProduct3&lt;<span class="pl-smi">String</span>, <span class="pl-smi">Integer</span>, <span class="pl-smi">Character</span>&gt;</span> integer <span class="pl-k">=</span> <span class="pl-smi">CoProduct3</span><span class="pl-k">.</span>b(<span class="pl-c1">1</span>);

<span class="pl-k">CoProduct3&lt;<span class="pl-smi">String</span>, <span class="pl-smi">Integer</span>, <span class="pl-smi">Character</span>&gt;</span> character <span class="pl-k">=</span> <span class="pl-smi">CoProduct3</span><span class="pl-k">.</span>c(<span class="pl-s"><span class="pl-pds">'</span>a<span class="pl-pds">'</span></span>);</pre></div>

<p>Rather than supporting explicit value unwrapping, which would necessarily jeopardize type safety, <code>CoProduct</code>s support a <code>match</code> method that takes one function per possible value type and maps it to a final common result type:</p>

<div class="highlight highlight-source-java"><pre><span class="pl-k">CoProduct3&lt;<span class="pl-smi">String</span>, <span class="pl-smi">Integer</span>, <span class="pl-smi">Character</span>&gt;</span> string <span class="pl-k">=</span> <span class="pl-smi">CoProduct3</span><span class="pl-k">.</span>a(<span class="pl-s"><span class="pl-pds">"</span>string<span class="pl-pds">"</span></span>);

<span class="pl-k">CoProduct3&lt;<span class="pl-smi">String</span>, <span class="pl-smi">Integer</span>, <span class="pl-smi">Character</span>&gt;</span> integer <span class="pl-k">=</span> <span class="pl-smi">CoProduct3</span><span class="pl-k">.</span>b(<span class="pl-c1">1</span>);

<span class="pl-k">CoProduct3&lt;<span class="pl-smi">String</span>, <span class="pl-smi">Integer</span>, <span class="pl-smi">Character</span>&gt;</span> character <span class="pl-k">=</span> <span class="pl-smi">CoProduct3</span><span class="pl-k">.</span>c(<span class="pl-s"><span class="pl-pds">'</span>a<span class="pl-pds">'</span></span>);

<span class="pl-smi">Integer</span> result <span class="pl-k">=</span> string<span class="pl-k">.</span><span class="pl-k">&lt;</span><span class="pl-smi">Integer</span><span class="pl-k">&gt;</span>match(<span class="pl-smi">String</span><span class="pl-k">::</span>length, identity(), <span class="pl-smi">Character</span><span class="pl-k">::</span>charCount); <span class="pl-c">// 6</span></pre></div>

<p>Additionally, because a <code>CoProduct2&lt;A, B&gt;</code> guarantees a subset of a <code>CoProduct3&lt;A, B, C&gt;</code>, the <code>diverge</code> method exists between <code>CoProduct</code> types of single magnitude differences to make it easy to use a more convergent <code>CoProduct</code> where a more divergent <code>CoProduct</code> is expected:</p>

<div class="highlight highlight-source-java"><pre><span class="pl-k">CoProduct2&lt;<span class="pl-smi">String</span>, <span class="pl-smi">Integer</span>&gt;</span> coProduct2 <span class="pl-k">=</span> <span class="pl-smi">CoProduct2</span><span class="pl-k">.</span>a(<span class="pl-s"><span class="pl-pds">"</span>string<span class="pl-pds">"</span></span>);

<span class="pl-k">CoProduct3&lt;<span class="pl-smi">String</span>, <span class="pl-smi">Integer</span>, <span class="pl-smi">Character</span>&gt;</span> coProduct3 <span class="pl-k">=</span> coProduct2<span class="pl-k">.</span>diverge(); <span class="pl-c">// still just the coProduct2 value, adapted to the coProduct3 shape</span></pre></div>

<p>There are <code>CoProduct</code> specializations for type unions of up to 5 different types: <code>CoProduct2</code> through <code>CoProduct5</code>, respectively.</p>

<p><code>Either&lt;L, R&gt;</code> represents a specialized <code>CoProduct2&lt;L, R&gt;</code>, which resolve to one of two possible values: a left value wrapping an <code>L</code>, or a right value wrapping an <code>R</code> (typically an exceptional value or a successful value, respectively).</p>

<p>As with <code>CoProduct2</code>, rather than supporting explicit value unwrapping, <code>Either</code> supports many useful comprehensions to help facilitate type-safe interactions: </p>

<span class="pl-smi">Integer</span> result <span class="pl-k">=</span> right<span class="pl-k">.</span>orElse(<span class="pl-k">-</span><span class="pl-c1">1</span>);

<span class="pl-c">//-&gt; 1</span>

</section>

<footer>

<p><small>Hosted on <a href="https://pages.github.com">GitHub Pages</a> using the Dinky theme</small></p>

</footer>

fixScale = function(doc) {

var addEvent = 'addEventListener',

type = 'gesturestart',

qsa = 'querySelectorAll',

scales = [1, 1],

meta = qsa in doc ? doc[qsa]('meta[name=viewport]') : [];

function fix() {

meta.content = 'width=device-width,minimum-scale=' + scales[0] + ',maximum-scale=' + scales[1];

doc.removeEventListener(type, fix, true);

}

if ((meta = meta[meta.length - 1]) && addEvent in doc) {

fix();

scales = [.25, 1.6];

doc[addEvent](type, fix, true);

}