## Different types of terms (resources)

### IRIs

```golang
// Create a new IRI
iri := NewResource("https://example.org")
iri.String() // ->
```

### Literals

```golang
// Create a new simple Literal
lit := NewLiteral("hello world")
lit.String() // -> "hello word"

// Create a new Literal with language tag
lit := NewLiteralWithLanguage("hello world", "en")
lit.String() // -> "hello word"@en

// Create a new Literal with a data type
lit := NewLiteralWithDatatype("newTypeVal", NewResource("https://datatype.com"))
lit.String() // -> "newTypeVal"^^
```

### Blank Nodes

```golang
// Create a new Blank Node with a given ID
bn := NewBlankNode(9)
bn.String() // -> "_:n9"

// Create an anonymous Blank Node with a random ID
abn := NewAnonNode()
abn.String() // -> "_:n192853"
```

## Parsing data

The parser takes an `io.Reader` as first parameter, and the string containing the mime type as the second parameter.

Currently, the supported parsing formats are Turtle (with mime type `text/turtle`) and JSON-LD (with mime type `application/ld+json`).

### Parsing Turtle from an io.Reader

```golang
// Set a base URI
baseUri := "https://example.org/foo"

// Create a new graph
g := NewGraph(baseUri)

// r is of type io.Reader
g.Parse(r, "text/turtle")
```

### Parsing JSON-LD from an io.Reader

```golang
// Set a base URI
baseUri := "https://example.org/foo"

// Create a new graph
g := NewGraph(baseUri)

// r is an io.Reader
g.Parse(r, "application/ld+json")
```

### Parsing either Turtle or JSON-LD from a URI on the Web

In this case you don't have to specify the mime type, as the internal http client will try to content negotiate to either Turtle or JSON-LD. An error will be returned if it fails.

**Note:** The `NewGraph()` function accepts an optional parameter called `skipVerify` that is used to tell the internal http client whether or not to ignore bad/self-signed server side certificates. By default, it will not check if you omit this parameter, or if you set it to `true`.

```golang
// Set a base URI
uri := "https://example.org/foo"

// Check remote server certificate to see if it's valid
// (don't skip verification)
skipVerify := false

// Create a new graph. You can also omit the skipVerify parameter
// and accept invalid certificates (e.g. self-signed)
g := NewGraph(uri, skipVerify)

err := g.LoadURI(uri)
if err != nil {
// deal with the error
}
```

## Serializing data

The serializer takes an `io.Writer` as first parameter, and the string containing the mime type as the second parameter.

Currently, the supported serialization formats are Turtle (with mime type `text/turtle`) and JSON-LD (with mime type `application/ld+json`).

### Serializing to Turtle

```golang
// Set a base URI
baseUri := "https://example.org/foo"

// Create a new graph
g := NewGraph(baseUri)

triple := NewTriple(NewResource("a"), NewResource("b"), NewResource("c"))
g.Add(triple)

// w is of type io.Writer
g.Serialize(w, "text/turtle")
```

### Serializing to JSON-LD

```golang
// Set a base URI
baseUri := "https://example.org/foo"

// Create a new graph
g := NewGraph(baseUri)

triple := NewTriple(NewResource("a"), NewResource("b"), NewResource("c"))
g.Add(triple)