[XSLT] Toch niet helemaal je-van-het..

Pagina: 1
Acties:
  • 117 views sinds 30-01-2008
  • Reageer

Acties:
  • 0 Henk 'm!

Verwijderd

Topicstarter
Ik vind XML en XPath redelijk nuttige technieken, maar ik heb moeite met het waarderen van XSLT.

Eerst vertel ik even kort wat ik heb begrepen dat XSLT is, want de kans bestaat natuurlijk dat ik het gewoon helemaal verkeerd heb begrepen.

XSLT is een techniek om gecontroleerd source XML trees naar result XML trees te 'vertalen'. XSLT sheets zijn XML documenten, waarin elements uit de xsl namespace gebruikt worden om met behulp van XPath zogenaamde 'templates' te apply-en op stukken van de source tree. In deze templates kun je stukken result tree genereren, gebruik makend van het stuk source tree waarop het template ge-apply-t wordt. Tevens kun je in deze templates gebruik maken van nog meer elements uit de xsl namespace om simpele algoritmes te maken voor het genereren van stukken result tree. Zo kun je variabelen aanmaken, if-then constructies maken, lijsten sorteren, etc.

[als ik hierboven grove fouten heb gemaakt, lees dan niet verder want dan heb ik het gewoon verkeerd begrepen, en is de rest van mijn text onzin]

Wat is er mis ?

Dat is allemaal leuk en aardig, maar ik vind die hulpmiddelen (elements) voor het schrijven van 'algoritmes' veel te beperkt. De betreffende elements vormen in feite een zeer beperkte script-taal. Je bent ermee aan het programmeren, maar dan via omslachtige XML elementen. Ik vind dit systeem waardeloos; zoals gezegd vind ik het beperkt en omslachtig. Wat ik graag zou zien is de mogelijkheid om een script-taal naar keuze te kunnen gebruiken voor dit soort zaken. Ik vind de mogelijkheden die de elements uit de xsl namespace bieden niet genoeg om echt interessante transformatie-sheets mee te kunnen bouwen.

Kortom: Het idee van templates die je apply't op stukken source tree (geselecteerd met een XPath query) om een result tree te genereren spreekt me zeker aan, maar verder vind ik dat XSLT absoluut onvoldoende middelen biedt om 'intelligente' XSLT sheets te schrijven.

Das naar voor je, maar wat wil je nu van ons ?

Ik wil graag weten of er meer mensen zijn die dit gevoel hebben gehad bij het schrijven van XSL sheets :).

----------- edit:

Ik vond trouwens in een andere thread de volgende uitspraak van mbravenboer:
XSLT vind ik eigenlijk zelfs wat beperkt voor echt zinvolle transformaties.
Bedoelt mbravenboer hiermee ongeveer wat ik hierboven bespreek ?

Acties:
  • 0 Henk 'm!

  • marcusk
  • Registratie: Februari 2001
  • Laatst online: 26-09-2023
mja... ik ben het eigenlijk wel met je eens. op zich is het xslt-idee goed, maar het nut van de xml-syntax ervan ontgaat me een beetje. dat maakt de code niet bepaald leesbaarder. xml syntax is immers niet bedoeld voor een script/programmeertaal. daarnaast is het inderdaad vrij beperkt. ondanks deze bezwaren vind ik xslt overigens wel erg handig :)

Acties:
  • 0 Henk 'm!

  • Rense Klinkenberg
  • Registratie: November 2000
  • Laatst online: 23-07 22:16
Op zich heb je wel gelijk met wat je zegt. Je kan met xslt niet complete regex dingen doen of what-ever. Gelukkig hebben ze bij het w3 consortium ook ingezien dat er meer zou moeten kunnen met xslt. Dat hadden ze al bedacht in de eerste standaard. Helaas zijn ze er toen niet aan toe gekomen om vast te stellen hoe dat geïmplementeerd moest worden.

De mooiste manier is nl. dat het wel compleer generiek gebeurd, zodat het later ook makkelijk is uit te breiden en aan te passen.

Hetgeen waar ik op doen zijn de zogenaamde extensies voor xslt. Hierdoor is het mogelijk om bijv. javascript functies aan te roepen en daar mee te werken alsof het XPath functies zijn. Hiermee kan je dus met 'gewone' programeertalen dingen oplossen die met xslt erg complex zouden worden of niet eens zijn op te lossen.

De xslt parser die in java erg veel gebruikt wordt (Xalan) ondersteund zelf extensies in java. Hierdoor kan je dus gewoon java functies (of methodes, maar ik ben geen java kenner) gebruiken in je transformaties.

Het nadeel is echter dat het nog niet compleet vast ligt in de huidige standaard. Ik dacht dat het in de nieuwe standaard wel vast lag, zodat je je xslt ook overal kan toe passen.

* Rense Klinkenberg gaat nu op zoek nar wat linkjes hierover

Acties:
  • 0 Henk 'm!

  • mbravenboer
  • Registratie: Januari 2000
  • Laatst online: 07-10-2022
Sneech: Ik vind XML en XPath redelijk nuttige technieken, maar ik heb moeite met het waarderen van XSLT.
Kan ik inkomen...
als ik hierboven grove fouten heb gemaakt
Je omschrijft het vrij gedetailleerd en niet astract, maar het klopt tot in detail wel :) .
Dat is allemaal leuk en aardig, maar ik vind die hulpmiddelen (elements) voor het schrijven van 'algoritmes' veel te beperkt. De betreffende elements vormen in feite een zeer beperkte script-taal. Je bent ermee aan het programmeren, maar dan via omslachtige XML elementen. Ik vind dit systeem waardeloos;
Allereerst je laatste punt: omslachtige XML elememten. Daar zit zeker wat in en het is een veel gehoorde kritiek.

Maar in principe is het niet relevant voor de 'kracht' van XSLT. De syntax van XSLT is (helaas?) XML. Hierdoor maak je gebruik van XML elementen die verdacht veel lijken om wat je normaal een abstract-syntax tree zou noemen in bijvoorbeeld een compiler. Dit is een zeer omslachtige notatie en hiermee val je eigenlijk de gebruiker lastig met een parsing probleem. Luiheid dus wellicht.

Neem bijvoorbeeld eens dit stukje XSLT:
code:
1
2
3
<xsl:if test=".... (ongemakkelijke conditie)">
     ... (insert een stukje result tree)
</xsl:if>

Dit zou je in een gewone programmeertaal bijvoorbeeld zo kunnen schrijven:
code:
1
2
3
4
if( conditie )
{
    insert stukje tree
}

Dit is uiteraard veel compacter, maar het is nu eenmaal een beslissing die genomen is bij XSLT. De XSLT variant is precies een abstract-syntax-tree die je zou verwachten bij het stukje 'bekende' syntax. Gelukkig hebben ze er niet voor gekozen om ook nog een XML syntax voor XPath te gebruiken, maar de huidige combinatie van XML structuur versus XPath expressies is eigenlijk uiterest merkwaardig.

Dan over de kracht:

XSLT probeert declaratief te zijn. Dit betekent dat je in een XSL Transformatie zoveel mogelijk abstraheert van de concrete uitvoering van een transformatie en zoveel mogelijk probeert aan te geven wat de transformatie is die je wilt uitvoeren.

Omdat XSLT niet imperatief is (wat jij dus eigenlijk wilt) heeft het ook wat beperkingen waarmee je moet leren leven. De keuzes die bij XSLT gemaakt zijn zorgen echter ook voor een niet al te complexe taal... XSLT is niet bedoeld als general-purpose transformatie-taal, maar dat laatste zou er wellicht wel moeten komen.
Ik vind de mogelijkheden die de elements uit de xsl namespace bieden niet genoeg om echt interessante transformatie-sheets mee te kunnen bouwen.
Tja, wat vind je interessant? Eigenlijk word ik nog regelmatig verrast door de kracht van het structurele-recursieve systeem van XSLT. Andere transformatie-talen werken eigenlijk vaak op dezelfde manier , maar zijn vaak wat generieker.
maar verder vind ik dat XSLT absoluut onvoldoende middelen biedt om 'intelligente' XSLT sheets te schrijven.
Dat is dus ook niet het doel van XSLT: XSLT is bedoeld voor het herstructuren van XML naar andere vormen. Echte complexe transformaties waarbij bijvoorbeeld een state belangrijk is, kan je er niet mee beschrijven.

Das naar voor je, maar wat wil je nu van ons ?
Ik wil graag weten of er meer mensen zijn die dit gevoel hebben gehad bij het schrijven van XSL sheets :).
Ja, dat heb ik ook :) . Je kunt wel extenties gebruiken in een bepaalde taal (Javascript of zelfs java of wat dan ook), maar dat is nogal een work-around...

De grootste beperking van XSLT vind ik eigenlijk dat resultaat ook altijd resultaat is. Je kunt nooit een transformatie uitvoeren (templates toepassen) op een result-tree. Dat is toch iets wat je vaak heel goed zou kunnen gebruiken. Dat variabelen immutable zijn vind ik een goede keuze. Het kan heel verwarrend overkomen op mensen met een imperatieve achtergrond, maar het is 1 van de belangrijkste voordelen van declaratieve talen.

Gelukkig zijn er echter alternatieven :) . Persoonlijk ben ik bijzonder gecharmeerd van de transformatie-taal 'Stratego'.

De basis van deze taal is vrij eenvoudig en je kunt er werkelijke grandioos allerlei complexe transformaties in uitvoeren. Er zijn in Stratego vrijwel geen beperkingen. Ik ben zelfs bezig met het schrijven van een compiler met behulp van tranformaties in Stratego. Het zal je verbazen hoe fraai je dit kunt uitdrukken. :) .

Stratego kan je wel een generieke transformatie taal noemen. Dit heeft echter ook zijn prijs: de taal is stukje complexer dan XML (althans, eigenlijk is hij een stuk eenvoudiger omdat er maar enkele noties zijn). Ook ontbreken er nog een aantal zaken die eigenlijk wel zeer nuttig zijn. Er is bijvoorbeeld geen declaratieve manier om path expressies aan te geven. Alles gaat op basis van pattern-matching. Deze path taal zit er echter wel aan te komen :) .

Stratego en andere transformatie-talen zijn op dit moment volop in ontwikkeling, maar worden vrijwel alleen nog maar gebruikt in de wetenschappelijke wereld. Stratego is ook nog niet geschikt voor het transformeren van XML (het data-type van Stratego is ATermen, vergelijkbaar met XML). Dit is echter een vrij vanzelfsprekende uitbreiding, waar op dit moment aan gewerkt wordt.

Wellicht vind je het leuk om Stratego eens te bekijken:
http://www.stratego-language.org

De documentatie is nog wat beperkt, maar met name de slides die je kan vinden in de sectie 'documentation' zijn behoorlijk goed :) . Met vragen kan je uiteraard hier terecht :) .
Bedoelt mbravenboer hiermee ongeveer wat ik hierboven bespreek ?
Ja, maar ik bedoel zeker niet dat XSLT zinloos is :) .

Blog, Stratego/XT: Program Transformation, SDF: Syntax Definition, Nix: Software Deployment


Acties:
  • 0 Henk 'm!

Verwijderd

Topicstarter
mbravenboer:

Bedankt voor je uitvoerige reply. Op zich vind ik het al geruststellend dat ik niet de enige ben die er zo over denkt, en dat er door verschillende mensen gewerkt wordt aan alternatieven of extensies.

Ik denk dat ik maar eens wat over dat Stratego ga lezen. Nadeel is natuurlijk wel dat je de client niet het tranformeer-werk kan laten doen zoals dat nu met xml+xsl mogelijk is, maar dat terzijde.

Acties:
  • 0 Henk 'm!

  • mbravenboer
  • Registratie: Januari 2000
  • Laatst online: 07-10-2022
Sneech: Ik denk dat ik maar eens wat over dat Stratego ga lezen.
Je moet het voorlopig vooral beschouwen als informatie hoe het anders kan. Stratego kan wel geinterpreteerd worden, maar wordt op dit moment gecompileerd naar C. Het draait ook alleen onder Linux. Dat werkt allemaal nogal beperkend, maar er zal zeker gewerkt worden aan compilate naar andere talen zoals Java. Omdat de Stratego compiler is opgebouwd uit componenten en ook geimplementeerd is in Stratego zelf, is dit niet al te lastig.
Nadeel is natuurlijk wel dat je de client niet het tranformeer-werk kan laten doen zoals dat nu met xml+xsl mogelijk is, maar dat terzijde.
Tja, maar client-side transformatie is sowieso voorlopig nogal kansloos en niet al te interessant :) .Transformatie is ook absoluut niet beperkt tot client-side transformatie van een XML bron in een browser. Er zijn veel interessantere toepassingen.

Blog, Stratego/XT: Program Transformation, SDF: Syntax Definition, Nix: Software Deployment


Acties:
  • 0 Henk 'm!

Verwijderd

Je kunt ook zeggen dat xslt te veel gehyped is. Ik denk dat xslt best bruikbaar is, maar beperkt.

Op het werk gaan we het gebruiken voor help en foutcodes. Op deze manier zijn de teksten beheerbaar. De help-teksten worden getransformeerd naar html bestanden, en de foutcodes naar html-part server-side includes.

Je zou ook een database kunnen gebruiken, maar die zit niet in het project, en tevens hoeven de helpteksten niet on-line te worden gewijzigd. Al met al ben ik best blij dat xslt bestaat :)

Mijn enige maar: grouping moet beter ondersteund worden. Voor de rest, je kunt toch ook delen van een xml-boom transformeren met xslt, en de moeilijke dingen met een "gewone" programmeertaal doen?

Acties:
  • 0 Henk 'm!

  • mbravenboer
  • Registratie: Januari 2000
  • Laatst online: 07-10-2022
Doekman: Mijn enige maar: grouping moet beter ondersteund worden.
Dan wordt jij blij van XSLT 2.0:
http://www.w3.org/TR/xslt20/#grouping
Voor de rest, je kunt toch ook delen van een xml-boom transformeren met xslt, en de moeilijke dingen met een "gewone" programmeertaal doen?
Yep, dat kan.

Overigens een aantal toepassingen waar ik XSLT voor gebruik:
- Desugaring van XML formaten voordat ik ze inlees
- Transformatie van zuivere XML formaten naar andere bestandsformaten. Ik gebruik bijvoorbeeld voor een applicatie waar ik mee bezig ben een XML bestandsformaat. Dit moet echter tijdelijk omgezet worden naar plain-text voor een oud component: XSLT lost het op.
- Direct inlezen van XML documenten naar objecten
- Invoegen van navigatie elementen in een XHTML website

Blog, Stratego/XT: Program Transformation, SDF: Syntax Definition, Nix: Software Deployment


Acties:
  • 0 Henk 'm!

  • CyberSnooP
  • Registratie: Augustus 2000
  • Laatst online: 16-07 07:17

CyberSnooP

^^^^ schrijft --->

Op woensdag 23 januari 2002 22:29 schreef mbravenboer het volgende:
Overigens een aantal toepassingen waar ik XSLT voor gebruik:
- Desugaring van XML formaten voordat ik ze inlees
Desugaring??? Gewoon weglaten van dat geen wat je niet nodig hebt? (strippen)

|_____vakje______|


Acties:
  • 0 Henk 'm!

Verwijderd

Topicstarter
Hmm, leuk is dat..

De Stratego tutorial van www.stratego-language.org vond ik hardstikke interessant, tot ze als eerste voorbeeld "Simplification of Propositional Formulae" aandroegen. Ik wacht wel tot er wat meer toegankelijke documentatie beschikbaar komt. :z

Acties:
  • 0 Henk 'm!

  • mbravenboer
  • Registratie: Januari 2000
  • Laatst online: 07-10-2022
CyberSnooP: Desugaring??? Gewoon weglaten van dat geen wat je niet nodig hebt? (strippen)
Nou ja, niet echt alleen maar 'weglaten' :) . Ik doelde op het vervangen van structuren naar meer atomaire vormen. Je hoeft zo met minder varianten rekening te houden en dat is prettig :) .

Soms misbruik ik het ook om structuren die vanwege DOM/SAX/Pull minder prettig in te lezen zijn om te zetten naar een andere vorm ;) .

Blog, Stratego/XT: Program Transformation, SDF: Syntax Definition, Nix: Software Deployment


Acties:
  • 0 Henk 'm!

  • marcusk
  • Registratie: Februari 2001
  • Laatst online: 26-09-2023
Op woensdag 23 januari 2002 22:57 schreef Sneech het volgende:
De Stratego tutorial van www.stratego-language.org vond ik hardstikke interessant, tot ze als eerste voorbeeld "Simplification of Propositional Formulae" aandroegen. Ik wacht wel tot er wat meer toegankelijke documentatie beschikbaar komt. :z
Dat voorbeeld vond ik juist erg verhelderend :)

Acties:
  • 0 Henk 'm!

  • mbravenboer
  • Registratie: Januari 2000
  • Laatst online: 07-10-2022
Sneech: Hmm, leuk is dat..
Haha :D .
Wil je nu een geavanceerde transformatie taal of niet? ;) .

Het eerste voorbeeld is inderdaad wellicht voor saai, maar wel een erg goed voorbeeld... Als je even doorbijt komen er later wel interessantere voorbeelden :) .

Maar goed, ik moet toegeven dat de documentatie op dit moment zeer matig is. Daar zal echter zeker hard aan gewerkt worden :) . Documenteren is alleen niet zo leuk ;) .

Blog, Stratego/XT: Program Transformation, SDF: Syntax Definition, Nix: Software Deployment


Acties:
  • 0 Henk 'm!

Verwijderd

Topicstarter
Ik vind het nogal stom dat ik geacht word eerst propositional formulae te gaan bestuderen om het eerste (!) voorbeeld in de tutorial zowieso te kunnen proberen te begrijpen ! Ik heb nog nooit van propositional formulae gehoord, maar als ik google moet geloven heeft het iets te maken met wiskundige analyse van redeneringen..

Maargoed, zal wel aan mij liggen dan. :?

Acties:
  • 0 Henk 'm!

  • mbravenboer
  • Registratie: Januari 2000
  • Laatst online: 07-10-2022
Sneech: Ik vind het nogal stom dat ik geacht word eerst propositional formulae te gaan bestuderen om het eerste (!) voorbeeld in de tutorial zowieso te kunnen proberen te begrijpen !
Het gaat inderdaad wat snel, maar ja het is in principe ook documentatie voor academici. Voor hen zou dit gesneden koek moeten zijn.
Ik heb nog nooit van proposional formulae gehoord, maar als ik google moet geloven heeft het iets te maken met wiskundige analyse van redeneringen.
Het is een stuk simpeler en je kent het allang. Propositie logica kan je gewoon zien als een rekenkunde op booleans waarop je and, or en not en dergelijke gebruikt. Je kent dit allang vanuit allerlei talen:
code:
1
2
3
4
(a || b)
(a && b)
!a
(a || b) && c

Dit kan je vertalen naar een boom:
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<or>
    <a/>
    <b/>
</or>

<and>
    <a/>
    <b/>
</and>

<not>
    <a/>
</not>

<and>
    <or>
      <a/>
      <b/>
    </or>
    <c/>
</and>

of in ATermen:
code:
1
2
3
4
Or("a", "b")
And("a", "b")
Not("a")
And(Or("a", "b"), "c")

Is toch wel te begrijpen? :)

Blog, Stratego/XT: Program Transformation, SDF: Syntax Definition, Nix: Software Deployment


Acties:
  • 0 Henk 'm!

Verwijderd

XSLT is geen taal als VB of C++, maar een functionele taal zoals miranda. Het werkt met patternmatching: een functie met een bepaald predicaat matcht met de input en wordt dan uitgevoerd. het resultaat wordt als waarde teruggegeven aan de caller, bv een attribute tag.

Ik had hier eerst ook moeite mee, je denkt snel in forloops e.d. maar dat moet je niet doen. Op een gegeven moment snap je wel hoe je problemen moet oplossen en hoe je conversies het beste kunt maken.

Hieronder bv een stukje XSLT (jaja, met HTML, excuses Martin ;) ik heb echter geen ander voorbeeld voorhanden ;)), wat een XML boom omzet naar een HTML editor. Omdat de XML boom data bevat die de html controls moeten preselecten had ik een probleem: hoe emit je nu html die bv een dropdownbox preselect. Maar met patternmatching lukt dit goed: (excuses voor de fucked up layout :P). DIt is een template wat gehangen wordt in een XSL(T) wat wordt opgebouwd uit de Element viewer XSLT templates behorende bij een Item. (dus worden toegevoegd als template handlers in de XSLT van het item waar de elements bij horen).
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="Elements/Element[@ElementType='4' and @TemplateID='0']">
<tr>
<td colspan="3"><br /></td>
</tr>
<tr BGCOLOR="#E6F0F3">
    <td width="80%" class="elementdescription">
        <b><xsl:value-of select="@Description"/></b>
    </td>
    <td>
        <a href="#" onClick="window.open('../../../help/help_image.asp','helpscherm','width=600,height=500,menubar=no,scrollbars=yes,titlebar=no,status=no,menubar=no'); return false">
            <xsl:attribute name="onMouseOver">navOverOut('bthelp<xsl:value-of select="@OrderInItem"/>','abhelpon');</xsl:attribute>
            <xsl:attribute name="onMouseOut">navOverOut('bthelp<xsl:value-of select="@OrderInItem"/>','abhelpoff');</xsl:attribute>
        [img]"/admin\pics\helpbutton.gif"[/img]
            <xsl:attribute name="NAME">bthelp<xsl:value-of select="@OrderInItem"/></xsl:attribute>
        </img>
        </a>

    </td>
    <td class="elementtypeeditor" nowrap="1">
        type: plaatje
    </td>
</tr>
<tr BGCOLOR="#E6F0F3">
<td colspan="3">
        <input type="hidden">
            <xsl:attribute name="name">ElementID_<xsl:value-of select="@OrderInItem"/></xsl:attribute>
            <xsl:attribute name="value"><xsl:value-of select="@ElementID"/></xsl:attribute>
        </input>     
        <br clear="all" />
        <table border="0">
        <tr>
            <td>
                Filenaam:
            </td>
            <td>
                <input type="text" size="40" maxlength="190" readonly="1">
                    <xsl:attribute name="name">SrcPath_<xsl:value-of select="@OrderInItem"/></xsl:attribute>
                    <xsl:attribute name="value"><xsl:value-of select="ElementData/SrcPath"/></xsl:attribute>
                </input>
                <a href="javascript://" onmouseover="navOverOut('btnSpecify','abspecifyon');" onmouseout="navOverOut('btnSpecify','abspecifyoff');">
                    <xsl:attribute name="onclick">OpenImageWindow(<xsl:value-of select="@OrderInItem"/>);</xsl:attribute>
                    [img]"../../../pics/ab_specify.gif"[/img]
                </a>
                    <xsl:attribute name="name">btnSpecify_<xsl:value-of select="@OrderInItem"/></xsl:attribute>
            </td>
        </tr>
        <tr>
            <td>Rand om plaatje:</td>
            <td>
                <xsl:choose>
                    <xsl:when test="ElementData/Border[.]='True'">
                        <input type="checkbox"><xsl:attribute name="name">Border_<xsl:value-of select="@OrderInItem"/></xsl:attribute>
                        <xsl:attribute name="CHECKED">0</xsl:attribute>
                        </input>
                    </xsl:when>
                    <xsl:when test="ElementData/Border[.]='False'">
                        <input type="checkbox"><xsl:attribute name="name">Border_<xsl:value-of select="@OrderInItem"/></xsl:attribute>
                        </input>
                    </xsl:when>
                </xsl:choose>
            </td>
        </tr>
        <tr>
            <td>
                Plaats: 
            </td>
            <td>
                <select>
                    <xsl:attribute name="name">Alignment_<xsl:value-of select="@OrderInItem"/></xsl:attribute>
                    <xsl:apply-templates select="ElementData/Alignment" />
                </select>
            </td>
        </tr>
        <tr>
            <td>
                Alt beschrijving:
            </td>
            <td>
                <input type="text" size="25" maxlength="50">
                    <xsl:attribute name="name">Alt_<xsl:value-of select="@OrderInItem"/></xsl:attribute>
                    <xsl:attribute name="value"><xsl:value-of select="ElementData/Alt"/></xsl:attribute>
                </input>
            </td>
        </tr>
        <tr>
            <td>Is link:</td>
            <td>
                <xsl:choose>
                    <xsl:when test="ElementData/IsLink[.]='True'">
                        <input type="checkbox"><xsl:attribute name="name">IsLink_<xsl:value-of select="@OrderInItem"/></xsl:attribute>
                        <xsl:attribute name="CHECKED">0</xsl:attribute>
                        </input>
                    </xsl:when>
                    <xsl:when test="ElementData/IsLink[.]='False'">
                        <input type="checkbox"><xsl:attribute name="name">IsLink_<xsl:value-of select="@OrderInItem"/></xsl:attribute>
                        </input>
                    </xsl:when>
                </xsl:choose>
            </td>
        </tr>
        <tr>
            <td></td>
            <td>
                <table border="0">
                <tr>
                    <td>
                        URL:
                    </td>
                    <td>
                        <input type="text" size="25" maxlength="190">
                            <xsl:attribute name="name">LinkURL_<xsl:value-of select="@OrderInItem"/></xsl:attribute>
                            <xsl:attribute name="value"><xsl:value-of select="ElementData/LinkURL"/></xsl:attribute>
                        </input>
                    </td>
                </tr>
                <tr>
                    <td>
                        target: 
                    </td>
                    <td>
                        <select>
                            <xsl:attribute name="name">Target_<xsl:value-of select="@OrderInItem"/></xsl:attribute>
                            <xsl:apply-templates select="ElementData/Target" />
                        </select>
                    </td>
                </tr>
                </table>
            </td>
        </tr>
        </table>
    </td>
</tr>
</xsl:template>

<xsl:template match="Alignment[.='center' or .='']">
<option value="center" SELECTED="0">Gecentreerd</option>
<option value="left">Links</option>
<option value="right">Rechts</option>
</xsl:template>

<xsl:template match="Alignment[.='left']">
<option value="center">Gecentreerd</option>
<option value="left" SELECTED="0">Links</option>
<option value="right">Rechts</option>
</xsl:template>

<xsl:template match="Alignment[.='right']">
<option value="center">Gecentreerd</option>
<option value="left">Links</option>
<option value="right" SELECTED="0">Rechts</option>
</xsl:template>
<xsl:template match="Target[.='_blank' or .='']">
<option value="_blank" SELECTED="0">Openen in nieuw window</option>
<option value="_self">Openen in huidige window</option>
</xsl:template>

<xsl:template match="Target[.='_self']">
<option value="_blank">Openen in nieuw window</option>
<option value="_self" SELECTED="0">Openen in huidige window</option>
</xsl:template>
</xsl:stylesheet>

Acties:
  • 0 Henk 'm!

  • mbravenboer
  • Registratie: Januari 2000
  • Laatst online: 07-10-2022
Otis: XSLT is geen taal als VB of C++, maar een functionele taal zoals miranda. Het werkt met patternmatching: een functie met een bepaald predicaat matcht met de input en wordt dan uitgevoerd. het resultaat wordt als waarde teruggegeven aan de caller, bv een attribute tag.
Dit vind ik toch wel serieus afbreuk doen aan functionele talen. Je maakte in de RDDL thread ook al deze opmerking en ik blijf mij erover verbazen dat je XSLT een functioneel taal noemt.

Uiteraard is er pattern-matching, wat zwaar in functionele talen wordt gebruikt, een input en een output en immutable variablen, maar dat maakt het nog zeker geen volwaardge hogere-orde functionele taal! Hogere-orde templates heb ik bijvoorbeeld nog niet gevonden ;) .

De ontwikkelaar van Stratego durft zijn taal niet eens functioneel te noemen en deze heeft toch nog veel meer weg van dit paradigma (bijvoorbeeld een fraaie manier om map en fold uit te drukken).

XSLT is uiteraard niet imperatief, maar daarom ook niet gelijk functioneel (hangt er natuurlijk vanaf wat je functioneel noemt, maar als je Miranda noemt bedoelen we kennelijk ongeveer hetzelfde ;) ).

Overigens ben ik het wel volledig met je eens dat je niet moet denken in termen van for-loopjes. Je moet de recursieve gedachte van XSLT zoveel mogelijk uitbuiten. Als je de smaak van XSLT te pakken hebt blijkt het inderdaad nog geeneens zo'n zwak taaltje te zijn :) .

Blog, Stratego/XT: Program Transformation, SDF: Syntax Definition, Nix: Software Deployment


Acties:
  • 0 Henk 'm!

  • mbravenboer
  • Registratie: Januari 2000
  • Laatst online: 07-10-2022
Otis: jaja, met HTML, excuses Martin ;)
Hehe ;) .

Het ziet er overigens niet erg toegankelijk uit door al die Javascript stuff ;( .

Waarom gebruik je trouwens niet de verkorte attribuut notatie? Dat zou het een stuk duidelijker maken denk ik... Principes? ;) .

Blog, Stratego/XT: Program Transformation, SDF: Syntax Definition, Nix: Software Deployment


Acties:
  • 0 Henk 'm!

Verwijderd

Er bestaat tegenwoordig ook een (simpele) xml parser voor javascript (dus geen activex- of applet-geneuzel).

Zie http://www.jeremie.com/Dev/XML/

Acties:
  • 0 Henk 'm!

Verwijderd

Op woensdag 23 januari 2002 23:48 schreef mbravenboer het volgende:
[Otis: XLST is functionele taal]
Dit vind ik toch wel serieus afbreuk doen aan functionele talen. Je maakte in de RDDL thread ook al deze opmerking en ik blijf mij erover verbazen dat je XSLT een functioneel taal noemt.
Nou, ok het is wellicht wat zwaar uitgedrukt, maar ik kan zo 1 2 3 geen andere vergelijking vinden voor waar XSLT geplaatst moet worden in het spectrum van taalvormen. Ik viel ook eerst in de valkuil dat ik dacht dat met een loopje in XSLT het wel even zou doen. Maar dat viel tegen. Toen ik het benaderde als een functioneel-achtige taalvorm (beter? :)) viel het kwartje en was het simpel.
Uiteraard is er pattern-matching, wat zwaar in functionele talen wordt gebruikt, een input en een output en immutable variablen, maar dat maakt het nog zeker geen volwaardge hogere-orde functionele taal! Hogere-orde templates heb ik bijvoorbeeld nog niet gevonden ;) .
matching in memory: 'Hogere orde templates' ... 0 matches found. Wat zijn dat? Miranda (de taal :P) heb ik niet meer aangeraakt sinds 1992, dus dat is wat erm.. weggezakt :)
De ontwikkelaar van Stratego durft zijn taal niet eens functioneel te noemen en deze heeft toch nog veel meer weg van dit paradigma (bijvoorbeeld een fraaie manier om map en fold uit te drukken).
Ik bespeur een 'C++ is geen OO!' achtige discussie. :)
XSLT is uiteraard niet imperatief, maar daarom ook niet gelijk functioneel (hangt er natuurlijk vanaf wat je functioneel noemt, maar als je Miranda noemt bedoelen we kennelijk ongeveer hetzelfde ;) ).
Miranda heb ik gehad als voorbeeld van functionele taal. Ik vond echter dat bv Prolog op hetzelfde principe gebaseerd was, alleen had de backtracker daar wat meer features, maar taaltechnisch stak het ong. zo in elkaar, althans dat vond en vind ik: als er een match is met een rule (prolog) of functiedefinitie (miranda) dan wordt de body 'uitgevoerd'.
Overigens ben ik het wel volledig met je eens dat je niet moet denken in termen van for-loopjes. Je moet de recursieve gedachte van XSLT zoveel mogelijk uitbuiten. Als je de smaak van XSLT te pakken hebt blijkt het inderdaad nog geeneens zo'n zwak taaltje te zijn :) .
Precies. En dat kan een hele omschakeling zijn en ik herkende de OP's problemen ook meteen: 'huh hoe doe ik dat?', want wie denkt nu meteen aan een functioneel-achtige taalvorm...

Acties:
  • 0 Henk 'm!

Verwijderd

Op woensdag 23 januari 2002 23:52 schreef mbravenboer het volgende:
[..]
Het ziet er overigens niet erg toegankelijk uit door al die Javascript stuff ;( .
Valt wel mee in colorcoding. :) Het zijn blokken HTML die zijn omgezet in XSLT, dus dat maakt het simpeler, maar die javascriptshit is idd niet best, maar in HTML zelf is dat niet minder onduidelijk hoor. Maar als je 1 kleur hebt, zoals hier op het forum, dan is het wat een brei idd.
Waarom gebruik je trouwens niet de verkorte attribuut notatie? Dat zou het een stuk duidelijker maken denk ik... Principes? ;) .
Nee, onwetendheid denk ik. Dit stamt uit de tijd dat de MS XML parser nog in versie 2.5 zat, ong 8 maanden terug dacht ik, het was allemaal nog niet zo gefinalized. Dit werkte, dus is het zo opgelost. Wat is 'verkorte attribuut notatie' ? Want als het korter kan, is dat alleen maar mooi natuurlijk :) (En degene die deze templates maakt zal daar uiteraard ook heel blij mee zijn vermoed ik :))

Acties:
  • 0 Henk 'm!

  • Rense Klinkenberg
  • Registratie: November 2000
  • Laatst online: 23-07 22:16
Op donderdag 24 januari 2002 10:21 schreef Otis het volgende:
...Wat is 'verkorte attribuut notatie' ?...
als je nu hebt
code:
1
2
3
4
5
6
<xsl:template match="link">
    <a>
      <xsl:attribute name="href"><xsl:value-of select="address" /></xsl:element>
      <xsl:value-of select="description"/>
    </a>
</xsl:template>

dan kan je dat een stuk korter schrijven door
code:
1
2
3
4
5
<xsl:template match="link">
    <a href="{address}">
      <xsl:value-of select="description"/>
    </a>
</xsl:template>

persoonlijk vind ik het ook een stuk beter lezen ;)

Acties:
  • 0 Henk 'm!

Verwijderd

hartelijk dank! dat ga ik meteen in praktijk brengen :)

Acties:
  • 0 Henk 'm!

  • mbravenboer
  • Registratie: Januari 2000
  • Laatst online: 07-10-2022
Otis: Toen ik het benaderde als een functioneel-achtige taalvorm (beter? :)) viel het kwartje en was het simpel.
Daar kan ik me wel in vinden ja :) .
matching in memory: 'Hogere orde templates' ... 0 matches found. Wat zijn dat?
Hehe :) . Hogere orde functies is de ultieme combinatie in een echte functionele taal van
1. geneste functies met lexical-scope (of in normaal Nederlands: geneste functies kunnen variabelen uit een omringende functie gebruiken)
2. functies als argumenten en resultaten van andere functies.
Dit samen wordt dus een hogere orde functionele taal genoemd maar in de 'volksmond' noemt met eigenlijke alleen deze talen functioneel. Hogere-orde templates was dus een woordspeling daarop ;) .
Ik bespeur een 'C++ is geen OO!' achtige discussie. :)
Hehe, maar dan nog principieler ;) .
Miranda heb ik gehad als voorbeeld van functionele taal.
Misschien vind je dit dan een keer leuk om te lezen: een degelijk verhaaltje "Haskell for Miranda Programmers".
http://www.cs.mu.oz.au/tr_submit/test/cover_db/mu_TR_1999_14.html
Ik vond echter dat bv Prolog op hetzelfde principe gebaseerd was
Daar zit inderdaad ook wel wat in. Bij een functionele taal denk ik echter gelijk aan een een pure hogere-orude functionele taal... De principes komen natuurlijk wel overeen omdat het allemaal talen zijn die min of meer op dezelfde methode abstraheren van imperatieve talen. Daarom worden ze ook altijd declaratief genoemd, wat ik eigenlijk een hele vervelende benaming vind...

Blog, Stratego/XT: Program Transformation, SDF: Syntax Definition, Nix: Software Deployment

Pagina: 1