Question: Is there a way to insert in a collection of Cassandra a value with single quote? This is what I have:

Table:

```
CREATE TABLE test.test (
   name text PRIMARY KEY,
   values map<text, text>
)

```

Insert: 

```
INSERT INTO test (name, values) VALUES ( 'jos''emy',{'foo':'josemy''s house'});

```

Query:

```
SELECT * FROM  test;

```

```
 name    | values
---------+----------------------------
 jos'emy | {'foo': 'josemy''s house'}

```

As you can see, Cassandra replace the double quote in the simple "name" field, but does not replace the quotes in the field inside the map. The result I want is:

```
 name    | values
---------+----------------------------
 jos'emy | {'foo': 'josemy's house'}

```

Answer: 
You could leave the code as-is. TypeScript already figures out that the types of all the variables in your code by looking at the initial assignment. Hover over the variables and you will see the types it's figured out.

The main problem in the code is that the type of `func` is incorrect. This:

```
var func: () => () => number = ...

```

...should be this:

```
var func: () => number = ...

```

Note there's no need for the extra `() =>` because it's not a function that returns a function that returns a number. It's only a function that returns a number.

---

By the way, if you really want to explicitly type everything, here's another solution:

```
var func: () => number = (() => {

    var private_count: number = 0;

    var increment: () => number = () => {
        private_count += 1;
        return private_count;
    };

    return increment;
})();

```

But I would recommend just using implicit types (as long as they're not implicit `any` types), but that's just a personal preference:

```
var func = (() => {

    var private_count = 0;

    var increment = () => {
        private_count += 1;
        return private_count;
    };

    return increment;
})();

```
Here it is:

```
var func = ((): () => number => {

    var _count: number = 0;

    var increment: () => number = function (): number {

        _count += 1;

        return _count;
    }

    return increment;
})();

```

But adding an interface makes it easier.

```
interface Increment {
    (): number;
}

var func = ((): Increment => {

    var _count: number = 0;

    var increment: Increment = function () {

        _count += 1;

        return _count;
    }

    return increment;
})();

```