Keith Alexander kwijibo

#Datatypes

##Functions

Curried

When call a function with only some of its arguments, you get back a partially-applied function that only expects the remainding arguments: const add1 = R.add(1) // function add1(){...

Placeholders

#Dynamic Linked Data

status: DRAFT,EXPERIMENTAL

Traditional Linked Data is not very "browsable" and does not provide a way to get from a resource to a list of things of the same type, or from a page about a book to a list of books by the same author.

SPARQL is a powerful query language, but it is difficult to write queries without knowledge of both the dataset, and SPARQL. It is not always practical to provide a SPARQL endpoint for every dataset that publishes as Linked Data.

This document describes a simple HTTP-based query system for Linked Data to fill the gap between static documents and SPARQL.

#Why

##Structure

The basic structure that Turtle is built on is Entity Attribute Value. An entity can be thought of as a named set of key-value pairs.

entities are represented by identifiers.
attributes (properties) are also represented by identifiers (this allows the semantics of an attribute to be described, if so wished)
values may be an identifier (of an entity), a string, a number, or an ordered list.

	// submit :: event -> IO[ HttpGet[ Either [ HttpPost []]]]
	const submit = (event) => {
	return getFormFields()
	.map(incrementVersionNumber)
	.map(saveRecord)
	}

	// getFormFields :: () -> IO
	const getFormFields = () => IO(()=>{
	return lift()

	map(f,g)(x) //map(pipe(f,g), x)
	filter(f,g)(x) //filter(allPass(f,g), x)
	pipeP(f,g)(handleError)(x) //pipe(pipeP(f,g), p=>p.catch(handleError))(x)
	cond([f1,a1], [f2,a2])(x) //cond([[f1,a1], [f2,a2]], x)

	// httpGET :: url -> HttpGET
	const httpGET = (url) => {
	let transform = x => x
	const GET = {
	url: url,
	map: (f) => {
	transform = x => f(transform(x))
	return GET
	},
	fork: (reject,resolve) => {

	var prepend = first => second => first + second
	, prefix = (item, i) => `@prefix n${i}: <${item}> . \n`
	, mapI = R.addIndex(R.map)
	, insertIndex = (ns,uri) => ns.push(uri)-1
	, nsEnd = uri => Math.max(uri.lastIndexOf('#'), uri.lastIndexOf('/')) +1
	, lookup = ns => uri => { const i = ns.indexOf(uri); return 'n' + (i>-1)? i : insertIndex(ns,uri) }
	, change0 = R.over(R.lensIndex(0))
	, change1 = R.over(R.lensIndex(1))
	, literal = ({value,lang,datatype}) => '"'+ value.replace(/("\|\n)/g,'\\$1') + '"'+langTag(lang)+dataType(datatype)
	, langTag = lang => lang? '@'+lang : ''

	@prefix R: <npm:ramda/0.18.0> . #(made up) npm protocol to define the module as a namespace
	@prefix r: <http://www.w3.org/2000/01/rdf-schema#> .
	@prefix : <#> . #this will be the namespace defining the lang-specific terms like :Text, :Fun1
	@prefix owl: <#...> . #whatever the owl prefix is...

	#functions are relationships, aka predicates, aka properties, between inputs and outputs
	:STDOUT <app> :STDIN .

	#owl:propertyChainAxiom is a composition of properties/predicates
	<app> owl:propertyChainAxiom (

	//getFieldDefinition :: key -> [a] -> a
	var getFieldDefinition = r.useWith(
	r.find, // #final function :: Relation -> [a] -> a
	r.propEq(1), //takes `key` where [1]==key #function for 1st param
	r.identity //#placeholder func for 2nd param
	)

	// getFieldSpec :: String -> Object
	// getFieldSpec('duration')
	// > {type:'number', max:60, min: 1}